import axios from 'axios';
import env, { API_CONFIG } from '../config/env';
import { createAuthInterceptor } from '../services/auth';

// 定义通用响应类型
export interface BaseResponse<T = any> {
    code: number;
    data: T;
    message?: string;
    description?: string;
}

// 使用环境配置
export const BASE_URL = env.isTunnel ? 'http://47.109.146.201:6100/api' : API_CONFIG.baseURL;
export const URL = {
  BASE: BASE_URL,
  WEBSOCKET: env.isTunnel ? 'ws://47.109.146.201:6100' : API_CONFIG.wsURL
};

// 打印当前环境
console.log('当前环境:', env.isDev ? 'development' : (env.isTunnel ? 'tunnel' : 'production'));
console.log('API基础URL:', BASE_URL);
console.log('WebSocket URL:', URL.WEBSOCKET);

// 添加请求频率控制
// 存储最近的API请求时间戳
const apiRequestTimestamps = new Map<string, number>();
// 需要控制请求频率的API路径及其冷却时间(毫秒)
const apiRateLimits = {
  '/image/avatar/upload': 3000,
  '/image/blog/image/upload': 2000,
  // 可以添加其他需要限制的API
};

// 添加请求源计数器，用于调试
const requestSourceCounter = new Map<string, number>();

const myAxios = axios.create({
    baseURL: BASE_URL,
    timeout: 10000, // 添加超时设置
})

// 确保跨域请求发送Cookie
myAxios.defaults.withCredentials = true;

// 添加默认请求头
myAxios.defaults.headers.common['Content-Type'] = 'application/json';
myAxios.defaults.headers.post['Content-Type'] = 'application/json';

// 打印调试信息
console.log('Axios配置:', {
    baseURL: BASE_URL,
    withCredentials: myAxios.defaults.withCredentials
});

// 添加认证拦截器
myAxios.interceptors.request.use(createAuthInterceptor());

// 请求拦截器
myAxios.interceptors.request.use(function (config) {
    console.log('发送请求:', config.method?.toUpperCase(), config.url);
    console.log('请求头:', config.headers);
    console.log('请求数据:', config.data);
    
    // 添加时间戳防止GET请求被缓存
    if (config.method?.toLowerCase() === 'get' && config.url) {
        const timestamp = new Date().getTime();
        // 检查URL是否已有参数
        const separator = config.url.includes('?') ? '&' : '?';
        config.url = `${config.url}${separator}_t=${timestamp}`;
        console.log('添加时间戳防止缓存:', config.url);
    }
    
    // 添加Cookie调试信息
    console.log('当前Cookies:', document.cookie);

    // 请求来源跟踪
    const requestSource = new Error().stack;
    if (config.url) {
        const source = `${config.method}-${config.url}`;
        const count = requestSourceCounter.get(source) ?? 0;
        requestSourceCounter.set(source, count + 1);
        console.log(`请求计数 [${source}]: ${count + 1}次`);
    }
    
    // 检查请求频率限制
    if (config.url) {
        const url = config.url;
        // 检查是否是需要限制频率的API
        for (const [apiPath, cooldown] of Object.entries(apiRateLimits)) {
            // 使用更精确的路径匹配，避免误判
            if (url === apiPath || url.endsWith(apiPath)) {
                const now = Date.now();
                const lastRequestTime = apiRequestTimestamps.get(apiPath) ?? 0;
                const timeSinceLastRequest = now - lastRequestTime;
                
                console.log(`API路径: ${apiPath}, 上次请求: ${lastRequestTime}, 间隔: ${timeSinceLastRequest}ms, 冷却时间: ${cooldown}ms`);
                
                // 如果请求过于频繁，返回一个被拒绝的Promise
                if (timeSinceLastRequest < cooldown) {
                    console.warn(`请求 ${url} 过于频繁，已拒绝，冷却时间: ${cooldown}ms, 距离上次请求: ${timeSinceLastRequest}ms`);
                    const errorMessage = `请求过于频繁，请等待 ${Math.ceil((cooldown - timeSinceLastRequest) / 1000)} 秒后再试`;
                    const rateLimitError = new Error(errorMessage);
                    // 添加自定义属性
                    Object.assign(rateLimitError, {
                        response: {
                            data: {
                                code: 42900,
                                message: '请求过于频繁',
                                description: `请等待 ${Math.ceil((cooldown - timeSinceLastRequest) / 1000)} 秒后再试`
                            }
                        },
                        isRateLimitError: true
                    });
                    return Promise.reject(rateLimitError);
                }
                
                // 记录本次请求时间
                console.log(`更新API时间戳: ${apiPath} => ${now}`);
                apiRequestTimestamps.set(apiPath, now);
                break;
            }
        }
    }
    
    if (config.data instanceof FormData) {
        console.log('发送FormData数据');
        // FormData无法直接打印内容，但可以检查是否包含文件
        try {
            // 使用any类型避免TypeScript错误
            const formData = config.data as any;
            for (const pair of formData.entries()) {
                const [key, value] = pair;
                if (value instanceof File) {
                    console.log(`FormData包含文件: ${key}, 类型: ${value.type}, 大小: ${value.size}字节`);
                } else {
                    console.log(`FormData包含字段: ${key}`);
                }
            }
        } catch (e) {
            console.error('无法读取FormData内容:', e);
        }
    } else {
        console.log('请求数据:', config.data);
    }
    return config;
}, function (error) {
    console.error('请求错误:', error);
    return Promise.reject(error);
});

// 响应拦截器
myAxios.interceptors.response.use(function (response) {
    console.log('收到响应:', response.status, response.config.url);
    console.log('响应头:', response.headers);
    console.log('响应数据:', response.data);
    
    // 添加Cookie调试信息
    console.log('响应后Cookies:', document.cookie);
    
    // 如果响应是登录接口
    if (response.config.url === '/user/login') {
        if (response.data.code === 0 && response.data.data) {
            // 存储用户信息
            localStorage.setItem('user', JSON.stringify(response.data.data));
            console.log('登录成功，已保存用户信息到localStorage');
        }
    }
    
    // 未登录则跳转登录页
    if (response?.data?.code === 40100) {
        console.log('用户未登录，准备跳转到登录页');
        // 使用相对路径避免域名问题
        window.location.href = '/user/login';
    }
    
    // 确保响应格式统一，即使后端返回不同格式也能处理
    if (typeof response.data === 'object') {
        // 如果没有code字段，添加标准格式
        if (response.data.code === undefined) {
            return {
                code: 0,
                data: response.data,
                message: 'success'
            };
        }
    }
    
    return response.data;
}, function (error) {
    console.error('响应错误详情:', {
        message: error.message,
        code: error.code,
        name: error.name,
        stack: error.stack,
        config: {
            url: error.config?.url,
            method: error.config?.method,
            baseURL: error.config?.baseURL,
            headers: error.config?.headers,
        }
    });

    if (error.response) {
        console.error('服务器响应错误:', {
            status: error.response.status,
            statusText: error.response.statusText,
            headers: error.response.headers,
            data: error.response.data
        });
        
        // 如果服务器返回了错误数据，格式化返回
        if (error.response.data) {
            // 尝试标准化错误响应格式
            const errorData = error.response.data;
            if (typeof errorData === 'object') {
                // 如果已经有code字段，直接返回
                if (errorData.code !== undefined) {
                    return Promise.reject(errorData);
                }
                
                // 创建标准错误格式
                return Promise.reject({
                    code: error.response.status,
                    data: null,
                    message: errorData.message || '服务器错误',
                    description: errorData.description || error.response.statusText
                });
            }
        }
        
        // 默认错误响应
        return Promise.reject({
            code: error.response.status,
            data: null,
            message: '服务器错误',
            description: error.response.statusText
        });
    } else if (error.request) {
        console.error('请求未收到响应:', {
            request: error.request,
            message: '这通常意味着网络问题或CORS配置问题'
        });
        
        return Promise.reject({
            code: 50000,
            data: null,
            message: '网络错误',
            description: '请求未收到响应，请检查网络连接'
        });
    } else {
        console.error('请求配置错误:', {
            message: error.message,
            details: '这通常意味着请求配置有误或请求被拦截器拒绝'
        });
        
        return Promise.reject({
            code: 40000,
            data: null,
            message: '请求错误',
            description: error.message
        });
    }
});

export default myAxios;